import { findCart, deleteCart, getNewCartGoods, insertCart, mergeCart, updateCart, checkAllCart } from '@/api/cart'
// 购物车状态
export default {
  namespaced: true,
  state: () => {
    return {
      list: []
    }
  },
  mutations: {
    // 覆盖购物车数据
    setCartList (state, list) {
      state.list = list
    },
    // 删除购物车商品
    deleteCart (state, skuId) {
      const index = state.list.findIndex(item => item.skuId === skuId)
      state.list.splice(index, 1)
    },

    // 修改更新购物车商品
    updateCart (state, goods) {
      const obj = state.list.find(item => item.skuId === goods.skuId)
      if (!obj) return
      for (const key in goods) {
        // 做安全判断 防止用户传一些 无效的值
        if (goods[key] !== null && goods[key] !== undefined && goods[key] !== '') {
          obj[key] = goods[key]
        }
      }
    },

    // 加入购物车
    insertCart (state, payload) {
      const index = state.list.findIndex(item => item.skuId === payload.skuId)
      //  情况1：没有添加过的就添加到列表前
      if (index === -1) {
        state.list.unshift(payload)
      } else {
        //  情况2：已经添加过的商品(skuid已存在)，是数量的累加
        state.list[index].count += payload.count
      }
    }
  },

  actions: {
    async  mergeLocalCart (store) {
      // 合并购物车
      const data = store.state.list.map(({ skuId, selected, count }) => ({ skuId, selected, count }))
      await mergeCart(data)
      // 获取购物车列表
      const { result } = await findCart()
      // console.log(result) // 登录成功后的商品列表
      store.commit('setCartList', result) // 将登录后的商品再添加到list中
    },

    // 更改购物车中商品的规格
    updateCartSku (store, { oldSkuId, newSkuObj }) {
      // console.log(newSkuObj)
      return new Promise((resolve) => {
        if (store.rootState.user.profile.token) {
          const oldskuobj = store.state.list.find(item => item.skuId === oldSkuId)
          store.dispatch('deleteCart', oldSkuId) // 删除旧的
          // 3. 获取数据并改名更新(因为商品详情页和购物车列表页后端返回的字段名不同)
          // const { price: nowPrice, inventory: stock, oldPrice: price, skuId, attrsText } = newSkuObj
          // 4 合并成完整的购物车商品对象
          store.dispatch('insertCart', { skuId: newSkuObj.skuId, count: oldskuobj.count })
          console.log(oldskuobj.skuId)
          console.log(oldskuobj.count)
          resolve('线上修改规格成功')
        } else {
          // 1'查找出商品对象
          const oldskuobj = store.state.list.find(item => item.skuId === oldSkuId)
          console.log(oldskuobj, newSkuObj)
          // 2 console.log(oldskuobj)  购物车当前的商品
          store.commit('deleteCart', oldSkuId) // 删除旧的
          // 3. 获取数据并改名更新(因为商品详情页和购物车列表页后端返回的字段名不同)
          const { price: nowPrice, inventory: stock, oldPrice: price, skuId, attrsText } = newSkuObj
          // 4 合并成完整的购物车商品对象
          store.commit('insertCart', { ...oldskuobj, nowPrice, stock, price, skuId, attrsText })
          resolve('本地修改规格成功')
        }
      })
    },
    // 删除全部选中商品
    batchDeleteCart (store, isInvalid) {
      return new Promise((resolve) => {
        // 情况1：有登录
        if (store.rootState.user.profile.token) {
        // 登录后 TODO ...
          const ids = store.getters[isInvalid === true ? 'invalidList' : 'selectedList'].map(item => item.skuId)
          deleteCart(ids).then(() => {
            store.dispatch('findCartList')
          })
          console.log(ids)

          resolve('线上接口')
        } else {
          // 为true 则是无效列表 否则是选中商品列表
          store.getters[isInvalid === true ? 'invalidList' : 'selectedList'].forEach(item => {
            store.commit('deleteCart', item.skuId) // 更新取反后的 每项validList
          })
          resolve('删除成功')
        }
      })
    },
    // 全选
    checkAllCart (store, selected) {
      console.log(selected)
      return new Promise((resolve) => {
        // 情况1：有登录
        if (store.rootState.user.profile.token) {
        // 登录后 TODO ...
          const ids = store.getters.validList.map(item => item.skuId)
          console.log(ids)
          checkAllCart({ ids, selected }).then(() => {
            store.dispatch('findCartList')
          })
          resolve('线上接口')
        } else {
          // 有效列表 遍历 selected  赋值取反
          store.getters.validList.forEach(item => {
            item.selected = selected
            store.commit('updateCart', item) // 更新取反后的 每项validList
          })
          resolve('删除成功,本地操作')
        }
      })
    },
    // 更新购物车商品
    updateCart (store, goods) {
      return new Promise((resolve) => {
        // 情况1：有登录
        if (store.rootState.user.profile.token) {
        // 登录后 TODO ...
          updateCart(goods).then(() => {
            // console.log(11111111)
            store.dispatch('findCartList')
          })

          resolve('线上接口')
        } else {
          store.commit('updateCart', goods)
          resolve('更新成功,本地操作')
        }
      })
    },

    // 删除购物车商品
    deleteCart (store, skuId) {
      return new Promise((resolve) => {
        // 情况1：有登录
        if (store.rootState.user.profile.token) {
          deleteCart([skuId]).then(() => {
            console.log(11111111)
            store.dispatch('findCartList') // 删除后再 重获取购物车列表
          })
          // 登录后 TODO ...
          resolve('线上接口')
        } else {
          console.log(22222222)
          store.commit('deleteCart', skuId)
          resolve('删除成功,本地操作')
        }
      })
    },

    // 获取购物车列表
    findCartList (store) {
      return new Promise((resolve) => {
        // 情况1：有登录
        if (store.rootState.user.profile.token) {
          findCart().then(({ result }) => {
            store.commit('setCartList', result) // 重新覆盖 list
            resolve('获取购物车成功-线上')
          })
          resolve('线上接口')
        } else {
          // 情况2：未登录
          store.state.list.forEach((item) => {
            const { result } = getNewCartGoods(item.skuId)
            console.log(result)
          })
          resolve('本地操作')
        }
      })
    },
    // 加入购物车
    insertCart (store, payload) {
      return new Promise((resolve) => {
        // 情况1：有登录
        if (store.rootState.user.profile.token) {
          console.log(payload)
          // 登录后 TODO ...
          insertCart(payload).then(() => {
            store.dispatch('findCartList') // 寻找购物车列表 重赋值list
          })
          resolve('加入购物车成功-线上')
        } else {
          // 情况2：未登录
          // console.log(payload)
          store.commit('insertCart', payload)
          resolve('加入购物车成功-本地')
        }
      })
    }
  },

  // 相当于计算属性
  getters: {

    // 有效商品列表
    validList (state) {
      // 过滤出 有库存 且 库存有效
      return state.list.filter(item => item.stock && item.isEffective)
    },
    // 有效商品件数
    validTotal (state, getters) {
      return getters.validList.reduce((total, item) => item.count + total, 0)
    },
    // 有效商品金额   因设计语言精度问题 所以 *100 再 / 100
    validAmount (state, getters) {
      return getters.validList.reduce((total, item) => item.price * 100 * item.count + total, 0) / 100
    },
    // 无效商品列表
    invalidList (state) {
      return state.list.filter(item => !(item.stock > 0 && item.isEffective))
    },
    // 选中商品列表
    selectedList (state, getters) {
      return getters.validList.filter(item => item.selected)
    },
    // 选中商品件数
    selectedTotal (state, getters) {
      return getters.selectedList.reduce((p, c) => p + c.count, 0)
    },
    // 选中商品总金额
    selectedAmount (state, getters) {
      return getters.selectedList.reduce((p, c) => p + (c.nowPrice * 100 * c.count), 0) / 100
    },
    // 是否全选
    isCheckAll (state, getters) {
      // 选中列表长度不为0，并且 有效商品列表 与 选中商品列表相等
      return getters.selectedList.length !== 0 && getters.validList.length === getters.selectedList.length
    }
  }
}
